from database.settings import settings
from database.database import DBSessionManager
from models import VideoSource
from typing import Optional, Dict, Any, List


class VideoResourceDao:
    def __init__(self):
        # 获取全局配置的会话管理器配置
        self.session_config = settings.get_db_session_config(
            # 可以针对VideoResourceDao进行特殊配置
            exclude_fields=set()  # 如有需要可排除敏感字段
        )

    def create_video(self, video: VideoSource) -> Dict[str, Any]:
        """
        创建视频资源

        Args:
            video: 视频对象

        Returns:
            创建的序列化视频对象
        """
        with DBSessionManager(**self.session_config) as db:
            db.add(video)
            db.commit()
            # 返回序列化结果（自动序列化）
            return db.get_by_id(VideoSource, video.id)

    def get_video_by_id(self, video_id: str) -> Optional[Dict[str, Any]]:
        """
        通过ID获取视频

        Args:
            video_id: 视频ID

        Returns:
            序列化后的视频对象，如果不存在则返回None
        """
        with DBSessionManager(**self.session_config) as db:
            return db.get_by_id(VideoSource, video_id)

    def delete_task_video_by_id(self, video_id: str) -> bool:
        """
        删除视频资源

        Args:
            video_id: 视频ID

        Returns:
            是否删除成功
        """
        with DBSessionManager(**self.session_config) as db:
            # 使用更安全的方式删除，禁用会话同步
            result = db.query(VideoSource).filter(VideoSource.id == video_id).delete(
                synchronize_session=False
            )
            db.commit()
            return result > 0

    def get_all_videos(self) -> List[Dict[str, Any]]:
        """
        获取所有视频资源（自动序列化）

        Returns:
            序列化后的视频列表
        """
        with DBSessionManager(**self.session_config) as db:
            return db.all(db.query(VideoSource))

    def get_videos_by_category(self, category_id: str) -> List[Dict[str, Any]]:
        """
        按分类获取视频

        Args:
            category_id: 分类ID

        Returns:
            序列化后的视频列表
        """
        with DBSessionManager(**self.session_config) as db:
            return db.all(
                db.query(VideoSource)
                .filter(VideoSource.category_id == category_id)
                .order_by(VideoSource.order)
            )

    def batch_create_videos(self, videos: List[VideoSource], batch_size: int = 500) -> int:
        """
        分批次批量创建视频

        Args:
            videos: 视频对象列表
            batch_size: 批次大小

        Returns:
            创建的记录数
        """
        with DBSessionManager(**self.session_config) as db:
            return db.batch_insert(VideoSource, videos, batch_size)

    def update_video(self, video_id: str, update_data: Dict[str, Any]) -> int:
        """
        更新视频信息

        Args:
            video_id: 视频ID
            update_data: 更新数据

        Returns:
            更新的记录数
        """
        with DBSessionManager(**self.session_config) as db:
            # 使用高效更新方式，禁用会话同步
            result = db.query(VideoSource).filter(VideoSource.id == video_id).update(
                update_data,
                synchronize_session=False
            )
            return result

    def batch_update_video_statuses(self, video_ids: List[str], status: str) -> int:
        """
        批量更新视频状态（高效处理）

        Args:
            video_ids: 视频ID列表
            status: 新状态值

        Returns:
            更新的记录数
        """
        with DBSessionManager(**self.session_config) as db:
            # 使用高效批量更新方法
            status_map = {video_id: status for video_id in video_ids}
            return db.batch_update_by_ids(
                VideoSource,
                "id",
                status_map,
                status_field="status"
            )

    def process_videos_in_batches(self, process_func, filter_condition=None) -> int:
        """
        流式处理视频（避免内存问题）

        Args:
            process_func: 处理函数
            filter_condition: 过滤条件（可选）

        Returns:
            处理的记录数
        """
        with DBSessionManager(**self.session_config) as db:
            query = db.query(VideoSource)
            if filter_condition:
                query = query.filter(filter_condition)

            return db.process_in_batches(
                query,
                process_func,
                serialize=True
            )
